# -*- coding: utf-8 -*-
#Test sur les fonctions définies dans la classe d'analyse


import Lab2analyse
import unittest
import re


class TestSequenceFunctions(unittest.TestCase):
    # Initialisation des variables qui seront utilisées par les différents tests
    def setUp(self): 
        file_in =open("/Users/missmousseline/Documents/thibaut/poly/Lexique372.txt")
        file_in = file_in.read().decode('latin1 ').encode ('utf8 ')
        self.dic= Lab2analyse.create_dictionary(file_in,0,0,23)
        self.bad_word = ['auxx','instaree']
        self.bad_word_2 = ['','instaree']
        self.good_word_3 = ["l'homme"]
        self.bad_word_3 = ["l'ail l'oeilcd"]
        self.good_word = ['a',"l'instar"]
        self.good_word_4 = ['à',"jeun"]
        self.good_word_2 = ['mauvais']
        self.texte = ("un - texte test pour   essayer  ,, " "   , ")
    
    # On test que le dictonnaire est correctement crée : 
    # en vérifiant la présence ou l'abscence de certains mots de référence

    def test_dic_creation(self):
        self.assertIn("a l'instar",self.dic)
        self.assertIn("marché",self.dic)
        self.assertNotIn("courire",self.dic)
        
        
    # Test des valeurs calculés (nmbre de mots, syllabes, mots ignorés) par la fonction  lookup_list_in_di de lookup dans le dictionnaire : 
    # en injectant une liste de mots valide (avec accent, sans), et deux liste de mots non valides
    # on s'assure que les valeurs retournées sont correctes
        
    def test_lookup_list_in_dic(self):
        self.assertEqual(Lab2analyse.lookup_list_in_dic(self.good_word,self.dic)[1][0],3)
        self.assertEqual(Lab2analyse.lookup_list_in_dic(self.good_word_2,self.dic)[1][1],2)
        self.assertEqual(Lab2analyse.lookup_list_in_dic(self.bad_word_2,self.dic)[1][0],0)
        self.assertEqual(Lab2analyse.lookup_list_in_dic(self.bad_word_2,self.dic)[1][1],0)
        self.assertEqual(Lab2analyse.lookup_list_in_dic(self.bad_word,self.dic)[0],self.bad_word)
        self.assertEqual(Lab2analyse.lookup_list_in_dic(self.bad_word,self.dic)[1][1],0)
        
        
    # Test sur le découpage et la mise en forme d'une liste  par la fonction split_list_mots:
    # On s'assure que la liste en sortie ne contient plus de "," , " " et plus de '"'
     
    def test_split_list_mots(self):   
        liste = Lab2analyse.split_list_mots(self.texte)
        for mots in liste:
            self.assertEqual(len(re.findall(" ",mots)),0)
            self.assertEqual(len(re.findall(",",mots)),0)
            self.assertEqual(len(re.findall('"',mots)),0)
    
    
    # Test de recherche dans un dictionnaire :
    # On vérifie que la fonction last_lookup permet de matcher des mots que la fonction lookup_list_in_dic ne match pas
    # On vérfie aussi aussi que les mots non présents dans le dictionnaire ne sont pas matchés
    
    def test_last_lookup(self):
        self.assertEqual(Lab2analyse.last_lookup(self.good_word_3,self.dic)[1][0],2)    
        self.assertEqual(Lab2analyse.last_lookup(self.good_word_3,self.dic)[0],[])  
        self.assertEqual(Lab2analyse.last_lookup(self.bad_word_3,self.dic)[1][0],3)  
        self.assertEqual(Lab2analyse.last_lookup(self.bad_word_3,self.dic)[0][0],"oeilcd")   
        
        
    #test réalisé : on teste la fonction en envoyant une liste composé de deux éléments qui forment un mot.
    # On vérifie que des mots qui n'existent pas dans le dictionnaire sont retournés, et pour ceux existant dans le dictionnaire
    # le nombre de syllabes calculé est cohérent   
    
    def test_two_words_in_one_lookup(self):
        self.assertEqual(Lab2analyse.two_words_in_one_lookup(self.bad_word,self.dic)[0],self.bad_word)
        self.assertEqual(Lab2analyse.two_words_in_one_lookup(self.good_word,self.dic)[1][1],3)
        self.assertEqual(Lab2analyse.two_words_in_one_lookup(self.good_word_4,self.dic)[1][1],2)
    
    

if __name__ == '__main__':
    
    unittest.main()